import { asyncRoutes, constantRoutes } from '@/router'

/**
 * Use meta.role to determine if the current user has permission
 * @param roles
 * @param route
 */

// 判断 当前用户  是否有route路由权限
function hasPermission(roles, route) {
  // 路由上配置meta  和 meta.roles
  if (route.meta && route.meta.roles) {
    // return roles.some(role => route.meta.roles.includes(role))
    // includes 方法是 查询 数组中有没有 后面的值
    return roles.includes(route.meta.roles[0])
    // 能找到 表示有权限  返回true
    // 找不到 没权限
  } else {
    // 没有配 直接返回true 表示有权限
    return true
  }
}

/**
 * Filter asynchronous routing tables by recursion
 * @param routes asyncRoutes  动态路由
 * @param roles   当前用户 可访问的 路由地址
 */

// 方法是 返回  在routes内 当前用户有权限的路由
export function filterAsyncRoutes(routes, roles) {
  // 存放 可访问的 动态路由配置
  const res = []

  routes.forEach(route => {
    // tmp  每个路由对象
    const tmp = { ...route }
    // hasPermission  判断 是否有权限
    if (hasPermission(roles, tmp)) {
      // 有对应路由权限
      // 判断这个路由是否有子路由
      if (tmp.children) {
        // 如果有子路由
        tmp.children = filterAsyncRoutes(tmp.children, roles)
        // 当前用户有权限的 二级路由
      }
      // 添加  当可访问的当前路由及内部可访问的子路由
      res.push(tmp)
    }
  })

  // 所有可访问动态路由
  return res
}

const state = {
  routes: [],
  addRoutes: []
}

const mutations = {
  SET_ROUTES: (state, routes) => {
    state.addRoutes = routes
    state.routes = constantRoutes.concat(routes)
  }
}

const actions = {
  // 计算可访问 路由的action
  generateRoutes({ commit }, roles) {
    return new Promise(resolve => {
      let accessedRoutes = []
      // roles内有admin  表示 是超级用户
      if (roles.includes('admin')) {
        // 直接把所有的动态路由 返回
        accessedRoutes = asyncRoutes || []
      } else {
        // 不是超级用户  看权限
        // accessedRoutes 是当前用户可访问的动态路由
        accessedRoutes = filterAsyncRoutes(asyncRoutes, roles)
      }
      // 存到仓库
      commit('SET_ROUTES', accessedRoutes)
      // 返回 计算出的 可访问路由
      resolve(accessedRoutes)
    })
  }
}

export default {
  namespaced: true,
  state,
  mutations,
  actions
}
